const BASE_URL = '/citycode_m'

/**
 * 因为在权限中心配置的时候，有可能不是以'/'开头，这里统一加上prefix，并处理成'/'开头
 */
function handleHeaderUrl(url) {
  return url.indexOf('/') === 0 ? `${BASE_URL}${url}` : `${BASE_URL}/${url}`
}

/**
 * 从menuUrl中解析出模块名称
 */
function getModuleName(menuUrl) {
  menuUrl = menuUrl.indexOf('/') === 0 ? menuUrl.substr(1) : menuUrl
  return menuUrl.split('/')[0]
}

/**
 * 菜单数据结构构造
 * @param treeList 经过listToTree方法处理过后的数据
 */
function generateMenuConfig(treeList) {
  // 递归处理每一层的菜单数据
  function convertMenuData(menuItem) {
    const result = {
      name: menuItem.menuName,
      iconClassName: menuItem.iconName || undefined,
      // 非新窗口打开的，这里处理一下"/"开头的路径，把斜杠去掉
      path:
        menuItem.menuUrl.indexOf('/') === 0
          ? menuItem.menuUrl.substr(1)
          : menuItem.menuUrl
    }
    // 新窗口打开
    if (menuItem.openWay === '1') {
      result.target = '_blank'
      result.path = menuItem.menuUrl // 如果是新窗口打开的，就直接使用配置的url
    }
    if (menuItem.children && menuItem.children.length) {
      result.children = menuItem.children.map(child => convertMenuData(child))
    }
    return result
  }
  // 处理管理后台应用的菜单数据，进行聚合
  // function handleAdminConfig(list) {
  //   // 由于管理后台的菜单是多个子应用聚合起来的，所以这里也将config聚合起来
  //   const config = {
  //     menuMode: 'horizontal',
  //     menuData: list
  //       .filter(item => item.businessParam === 'admin')
  //       .map(adminItem => convertMenuData(adminItem))
  //   }
  //   return config
  // }
  // const adminMenuConfig = handleAdminConfig(treeList)
  // 菜单类型映射，普通业务系统用的'interrelation'，管理后台应用用的'horizontal'
  const menuModeMap = {
    // business: 'interrelation',
    business: 'interrelation',
    admin: 'interrelation'
  }
  const menuConfig = {}
  treeList.forEach(menuItem => {
    // TODO-JJ 默认设置都为admin
    // menuItem.businessParam = 'business'

    // 如果有二级菜单，就要渲染左侧sidebar里边的菜单，如果没有的话，就只有顶部的header入口，菜单又应用自己渲染，或者没有左侧菜单
    // 如果是系统应用，也要渲染菜单
    if (
      menuItem.businessParam === 'admin' ||
      (menuItem.children && menuItem.children.length)
    ) {
      const config = {}
      if (menuItem.businessParam === 'admin') {
        config.menuMode = menuModeMap.admin
        config.menuData = []
        if (menuItem.children && menuItem.children.length) {
          config.menuData = menuItem.children.map(child =>
            convertMenuData(child)
          )
        }
      } else {
        config.menuMode = menuModeMap[menuItem.businessParam] || 'interrelation'
        config.menuData = menuItem.children.map(child => convertMenuData(child))
      }
      // const config =
      //   menuItem.businessParam === 'admin'
      //     ? {
      //         menuMode: 'horizontal',
      //         // menuData: []
      //         menuData: menuItem.children.map(child => convertMenuData(child))
      //       }
      //     : {
      //         menuMode: menuModeMap[menuItem.businessParam] || 'interrelation',
      //         menuData: menuItem.children.map(child => convertMenuData(child))
      //       }
      menuConfig[menuItem.menuUrl] = config
    }
  })
  return menuConfig
}

/**
 * 顶部header数据结构构造
 * @param treeList 经过listToTree方法处理过后的数据
 */
function generateHeaderConfig(treeList) {
  const headerConfig = {
    entryList: [],
    entry: {}
  }
  const adminHeaderConfig = []
  // 分别处理管理后台应用和业务应用
  treeList.forEach(item => {
    if (item.businessParam === 'business' || !item.businessParam) {
      const moduleName = getModuleName(item.menuUrl)
      headerConfig.entryList.push(moduleName)
      headerConfig.entry[moduleName] = {
        name: item.menuName,
        url: handleHeaderUrl(item.menuUrl)
      }
    } else if (item.businessParam === 'admin') {
      adminHeaderConfig.push({
        name: item.menuName,
        url: handleHeaderUrl(item.menuUrl),
        icon: item.iconName || undefined,
        desc: item.description || '',
        action:
          item.openWay === '1'
            ? () => {
                window.open(item.menuUrl)
              }
            : undefined
      })
    }
  })
  if (adminHeaderConfig.length) {
    headerConfig.entryList.push(['admin'].concat(adminHeaderConfig))
    headerConfig.entry.admin = { name: '系统管理', url: '#' }
  }
  return headerConfig
}

/**
 * 将列表数据转换成树形结构，返回也是一个数组
 * @param menuList
 */
function listToTree(menuList) {
  menuList.forEach(element => {
    const { parentId, level } = element
    // level为1的表示顶层菜单，也就是子系统的入口
    if (level !== '1') {
      menuList.forEach(ele => {
        if (ele.menuId === parentId) {
          // 当内层循环的ID== 外层循环的parendId时，（说明有children），需要往该内层id里建个children并push对应的数组；
          if (!ele.children) {
            ele.children = []
          }
          ele.children.push(element)
        }
      })
    }
  })
  menuList = menuList.filter(ele => ele.level === '1') // 这一步是过滤，按树展开，将多余的数组剔除；
  menuList.sort((a, b) => {
    const rankA = a.ranked
    const rankB = b.ranked
    if (Number(rankA) && Number(rankB)) {
      return rankA - rankB
    } else if (Number(rankA)) {
      return -1
    } else {
      return 1
    }
  })
  return menuList
}

export { generateMenuConfig, generateHeaderConfig, listToTree }
